/*
 * File    : Download.java
 * Created : 06-Jan-2004
 * By      : parg
 * 
 * Azureus - a Java Bittorrent client
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details ( see the LICENSE file ).
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package org.gudy.azureus2.plugins.download;

import java.io.File;
import java.util.Map;

import org.gudy.azureus2.plugins.download.savelocation.DefaultSaveLocationManager;
import org.gudy.azureus2.plugins.download.savelocation.SaveLocationChange;
import org.gudy.azureus2.plugins.download.savelocation.SaveLocationManager;
import org.gudy.azureus2.plugins.peers.PeerManager;
import org.gudy.azureus2.plugins.torrent.Torrent;
import org.gudy.azureus2.plugins.torrent.TorrentAttribute;
import org.torrent.internal.data.TorrentMetaInfo;
//import org.gudy.azureus2.plugins.disk.DiskManager;
//import org.gudy.azureus2.plugins.disk.DiskManagerFileInfo;
//import org.gudy.azureus2.plugins.peers.PeerManager;

/**
 * Management of a Torrent's activity.
 * 
 * <b>Note:</b> All listener based methods are now located in {@link DownloadEventNotifier}.
 * 
 * <PRE>
 * A download's lifecycle:
 * torrent gets added
 *    state -> QUEUED
 * slot becomes available, queued torrent is picked, "restart" executed
 *    state -> WAITING
 * state moves through PREPARING to READY
 *    state -> PREPARING
 *    state -> READY
 * execute "start" method
 *    state -> SEEDING -or- DOWNLOADING
 * if torrent is DOWNLOADING, and completes, state changes to SEEDING
 *
 * Path 1                   | Path 2
 * -------------------------+------------------------------------------------
 * execute "stop" method    | startstop rules are met, execute "stopandQueue"
 *    state -> STOPPING     |     state -> STOPPING
 *    state -> STOPPED      |     state -> STOPPED
 *                          |     state -> QUEUED
 * execute "remove" method -> deletes the download
 * a "stop" method call can be made when the download is in all states except STOPPED
 * </PRE>
 *
 * @author parg
 */

public interface 
Download extends DownloadEventNotifier
{
  /** waiting to be told to start preparing */  
	public static final int ST_WAITING     = 1;
  /** getting files ready (allocating/checking) */  
	public static final int ST_PREPARING   = 2;
  /** ready to be started if required */  
	public static final int ST_READY       = 3;
  /** downloading */  
	public static final int ST_DOWNLOADING = 4;
  /** seeding */  
	public static final int ST_SEEDING     = 5;
  /** stopping */  
	public static final int ST_STOPPING    = 6;
  /** stopped, do not auto-start! */  
	public static final int ST_STOPPED     = 7;
  /** failed */  
	public static final int ST_ERROR       = 8;
  /** stopped, but ready for auto-starting */  
	public static final int ST_QUEUED      = 9;

	public static final String[] ST_NAMES = 
		{
			"",
			"Waiting",
			"Preparing",
			"Ready",
			"Downloading",
			"Seeding",
			"Stopping",
			"Stopped",
			"Error",
			"Queued",
		};
	
  /** Use more of the upload bandwidth than low priority downloads 
   *  don't change these as they are used by remote clients */
	
	public static final int	PR_HIGH_PRIORITY	= 1;
  /** Use less of the upload bandwidth than high priority downloads */  
	public static final int	PR_LOW_PRIORITY		= 2;
	
	
		/**
		 * Flags values
		 * @since 2.3.0.5
		 */
	
	public static final long FLAG_ONLY_EVER_SEEDED			= 0x00000001;
	public static final long FLAG_SCAN_INCOMPLETE_PIECES	= 0x00000002;
	
	/**
	 * Flag value - if set, it prevents any of the "move on completion" or
	 * "move on removal" rules taking place.
	 * 
	 * @since 2.5.0.1
	 */
	public static final long FLAG_DISABLE_AUTO_FILE_MOVE 	= 0x00000004;

    /**
     * Flag value - if set, then it means this download has been considered
     * for "move on completion", and it should not be considered again for
     * it. This value is more for internal use rather than plugin use.
     * 
     * @since 2.5.0.1
     */
    public static final long FLAG_MOVE_ON_COMPLETION_DONE	= 0x00000008;
	
    /**
     * Flag value - if set the user won't be bothered with popups/completion events during
     * the download's life. This is used, for example, for downloads used to run speed-tests
     * @since 3.0.1.3
     */
    
    public static final long FLAG_LOW_NOISE					= 0x00000010;

    	/**
    	 * Flag value - normally the permitted peer sources for a download are fixed and can't be changed
    	 * this flag allows the permitted peer source set to be increased/decreased (but not beyond the enforced
    	 * values required to honour a torrent's 'private' flag
    	 */
    public static final long FLAG_ALLOW_PERMITTED_PEER_SOURCE_CHANGES = 0x00000020;
    
    
    /**
     * Flag value - if set the data will not be delete when the download is "deleted" from
     * the v3 interface.
     * @since 3.1.0.0
     */
    public static final long FLAG_DO_NOT_DELETE_DATA_ON_REMOVE = 0x00000040;
    
	/** get state from above ST_ set
   * @return ST_ constant
   *
   * @since 2.0.7.0
   */
	public int
	getState();

//	/**
//	 * For the STOPPING state this method gives the state that is being transited too (STOPPED, QUEUED or ERROR)
//	 * @return
//	 * @since 2.3.0.5
//	 */
//
//	public int
//	getSubState();
//
//	/** When the download state is ERROR this method returns the error details
//   * @return
//   *
//   * @since 2.0.7.0
//   */
//	public String
//	getErrorStateDetails();
//
//		/**
//		 * Get the flag value
//		 * @since 2.3.0.5
//		 * @param flag	FLAG value from above
//		 * @return
//		 */
//
//	public boolean getFlag(long	flag);
//
//	/**
//	 * Set the flag value.
//	 *
//	 * @since 2.5.0.1
//	 * @param flag FLAG value from above
//	 * @param set <code>true</code> to enable the flag, <code>false</code> to disable it.
//	 */
//	public void setFlag(long flag, boolean set);
//
//	/**
//	 * get all the flags as a bitmap
//	 * @since 4209
//	 * @return
//	 */
//
//	public long
//	getFlags();
//
//	/**
//	 * Index of download. {@link #getPosition()}
//	 * @return	index - 0 based
//   *
//   * @since 2.0.7.0
//	 */
//	public int
//	getIndex();
//
//	/**
//	 * Each download has a corresponding torrent
//	 * @return	the download's torrent
//   *
//   * @since 2.0.7.0
//	 */
//	public Torrent
//	getTorrent();

        public TorrentMetaInfo getTorrent();

//
//	/**
//	 * See lifecycle description above
//	 * @throws DownloadException
//   *
//   * @since 2.0.7.0
//	 */
//	public void
//	initialize()
//
//		throws DownloadException;
//
//	/**
//	 * See lifecycle description above
//	 * @throws DownloadException
//   *
//   * @since 2.0.7.0
//	 */
//	public void
//	start()
//
//		throws DownloadException;
//
//	/**
//	 * See lifecycle description above
//	 * @throws DownloadException
//   *
//   * @since 2.0.7.0
//	 */
//	public void
//	stop()
//
//		throws DownloadException;
//
//	/**
//	 * See lifecycle description above
//	 * @throws DownloadException
//   *
//   * @since 2.0.8.0
//	 */
//	public void
//	stopAndQueue()
//
//		throws DownloadException;
//
//	/**
//	 * See lifecycle description above
//	 * @throws DownloadException
//   *
//   * @since 2.0.7.0
//	 */
//	public void
//	restart()
//
//		throws DownloadException;
//
//
//		/**
//		 * Performs a complete recheck of the downloaded data
//		 * Download must be in stopped, queued or error state
//		 * Action is performed asynchronously and will progress the download through
//		 * states PREPARING back to the relevant state
//		 * @throws DownloadException
//		 * @since 2.1.0.3
//		 */
//
//	public void
//	recheckData()
//
//		throws DownloadException;
//
//	/**
//	 * When a download is "start-stop locked" it means that seeding rules shouldn't start or
//	 * stop the download as it is under manual control
//	 * @return True if download is locked and should not be started or stopped
//   *
//   * @since 2.0.7.0
//	 */
//	public boolean
//	isStartStopLocked();
//
  /** Retrieves whether the download is force started
   * @return True if download is force started.  False if not.
   *
   * @since 2.0.8.0
   */
	public boolean
	isForceStart();

  /** Set the forcestart state of the download
   * @param forceStart True - Download will start, despite any Start/Stop rules/limits<BR>
   * False - Turn forcestart state off.  Download may or may not stop, depending on
   * Start/Stop rules/limits
   *
   * @since 2.0.8.0
   */
	public void
	setForceStart(boolean forceStart);
//
//	/**
//	 * Downloads can either be low or high priority (see PR_ constants above)
//	 * @return the download's priority
//	 *
//	 * @deprecated >= 2.1.0.6 does nothing
//	 * @since 2.0.7.0
//	 */
//	public int
//	getPriority();
//
//	/**
//	 * This method sets a download's priority
//	 * @param priority the required priority, see PR_ constants above
//	 * @deprecated >= 2.1.0.6 does nothing
//	 *
//	 * @since 2.0.7.0
//	 */
//	public void
//	setPriority(
//		int		priority );
//
//	/** When a download's priority is locked this means that seeding rules should not change
//   * a downloads priority, it is under manual control
//   * @return whether it is locked or not
//   * @deprecated >= 2.0.8.0 does nothing
//   *
//   * @since 2.0.7.0
//   */
//	public boolean
//	isPriorityLocked();
//
//	/**
//	 * @since 2403
//	 * @return
//	 */
//
//	public boolean
//	isPaused();
//
//	/**
//	 * Pause the download
//	 * @since 2501
//	 */
//
//	public void
//	pause();
//
//	/**
//	 * Resume the download if paused
//	 * @since 2501
//	 */
//
//	public void
//	resume();
//
	/** Returns the name of the torrent.  Similar to Torrent.getName() and is usefull
   * if getTorrent() returns null and you still need the name.
   * @return name of the torrent
   *
   * @since 2.0.8.0
   */
	public String 
	getName();
//
//	/** Returns the full file path and name of the .torrent file
//	 *
//	 * @return File name of the torrent.
//   *
//   * @since 2.1.0.0
//	 */
//  public String getTorrentFileName();
//
//
//  	/**
//  	 * Gets an attribute of this download. For category use the Category torrent attribute
//  	 * @param attribute
//  	 * @return
//  	 */
//
//  public String
//  getAttribute(
//  	TorrentAttribute		attribute );
//
//  /**
//	 * Sets an attribute of this download. For category use the Category torrent attribute
//   *
//   * @param attribute Previously created attribute
//   * @param value Value to store.  null to remove attribute
//   */
//  public void
//  setAttribute(
//  	TorrentAttribute		attribute,
//	String					value );

  public String[]
  getListAttribute(
	TorrentAttribute		attribute );

//  /**
//   *
//   * @param attribute
//   * @param value
//   * @since 2.5.0.1
//   */
//  public void setListAttribute(TorrentAttribute attribute, String[] value);
//
//  /**
//   *
//   * @param attribute
//   * @param value		must be bencodable - key is string, value is Map, List, Long or byte[]
//   */
//
//  public void
//  setMapAttribute(
//	TorrentAttribute		attribute,
//	Map						value );
//
//  public Map
//  getMapAttribute(
//	TorrentAttribute		attribute );
//
//  /**
//   * Gets the value of the given attribute from the download. If no value is
//   * set, then <code>0</code> will be returned.
//   */
//  public int getIntAttribute(TorrentAttribute attribute);
//
//  /**
//   * Sets an integer attribute on this download.
//   */
//  public void setIntAttribute(TorrentAttribute attribute, int value);
//
//  /**
//   * Gets the value of the given attribute from the download. If no value is
//   * set, then <code>0</code> will be returned.
//   */
//  public long getLongAttribute(TorrentAttribute attribute);
//
//  /**
//   * Sets a long attribute on this download.
//   */
//  public void setLongAttribute(TorrentAttribute attribute, long value);
//
//  /**
//   * Gets the value of the given attribute from the download. If no value is
//   * set, then <code>false</code> will be returned.
//   */
//  public boolean getBooleanAttribute(TorrentAttribute attribute);
//
//  /**
//   * Sets a boolean attribute on this download.
//   */
//  public void setBooleanAttribute(TorrentAttribute attribute, boolean value);
//
//  /**
//   * Returns <code>true</code> if the download has an explicit value stored for
//   * the given attribute.
//   */
//  public boolean hasAttribute(TorrentAttribute attribute);
//
//  /** Returns the name of the Category
//   *
//   * @return name of the category
//   *
//   * @since 2.1.0.0
//   * @deprecated Use TorrentAttribute.TA_CATEGORY (2.2.0.3)
//   */
//  public String getCategoryName();
//
//  /** Sets the category for the download
//   *
//   * @param sName Category name
//   *
//   * @since 2.1.0.0
//   * @deprecated Use TorrentAttribute.TA_CATEGORY (2.2.0.3)
//   */
//  public void setCategory(String sName);
//
//	/**
//	 * Removes a download. The download must be stopped or in error. Removal may fail if another
//	 * component does not want the removal to occur - in this case a "veto" exception is thrown
//	 * @throws DownloadException
//	 * @throws DownloadRemovalVetoException
//   *
//   * @since 2.0.7.0
//	 */
//	public void
//	remove()
//
//		throws DownloadException, DownloadRemovalVetoException;
//
//		/**
//		 * Same as "remove" but, if successful, deletes the torrent and/or data
//		 * @param delete_torrent
//		 * @param delete_data
//		 * @throws DownloadException
//		 * @throws DownloadRemovalVetoException
//		 * @since 2.2.0.3
//		 */
//
//	public void
//	remove(
//		boolean	delete_torrent,
//		boolean	delete_data )
//
//		throws DownloadException, DownloadRemovalVetoException;
//
//	/**
//	 * Returns the current position in the queue
//	 * Completed and Incompleted downloads have seperate position sets.  This means
//	 * we can have a position x for Completed, and position x for Incompleted.
//   *
//   * @since 2.0.8.0
//	 */
//	public int
//	getPosition();
//
//		/**
//		 * returns the time this download was created in milliseconds
//		 * @return
//		 */
//
//	public long
//	getCreationTime();
//
//	/**
//	 * Sets the position in the queue
//	 * Completed and Incompleted downloads have seperate position sets
//   *
//   * @since 2.0.8.0
//	 */
//	public void
//	setPosition(
//		int newPosition);
//
//	/**
//	 * Moves the download position up one
//   *
//   * @since 2.1.0.0
//	 */
//	public void
//	moveUp();
//
//	/**
//	 * Moves the download down one position
//   *
//   * @since 2.1.0.0
//	 */
//	public void
//	moveDown();
//
//		/**
//		 * Moves a download and re-orders the others appropriately. Note that setPosition does not do this, it
//		 * merely sets the position thus making it possible, for example, for two downloads to have the same
//		 * position
//		 * @param position
//		 * @since 2.3.0.7
//		 */
//
//	public void
//	moveTo(
//		int		position );
//
//	/**
//	 * Tests whether or not a download can be removed. Due to synchronization issues it is possible
//	 * for a download to report OK here but still fail removal.
//	 * @return
//	 * @throws DownloadRemovalVetoException
//   *
//   * @since 2.0.7.0
//	 */
//	public boolean
//	canBeRemoved()
//
//		throws DownloadRemovalVetoException;
//
	public void
	setAnnounceResult(
		DownloadAnnounceResult	result );

////	public void
////	setScrapeResult(
////		DownloadScrapeResult	result );
////
	/**
	 * Gives access to the last announce result received from the tracker for the download
	 * @return
   *
   * @since 2.0.7.0
	 */

	public DownloadAnnounceResult
	getLastAnnounceResult();

////	/**
////	 * Gives access to the last scrape result received from the tracker for the download
////	 * @return a non-null DownloadScrapeResult
////   *
////   * @since 2.0.7.0
////	 */
////	public DownloadScrapeResult
////	getLastScrapeResult();
////
////	/**
////	 * Gives access to the current activation state. Note that we currently only fire the activation listener
////	 * on an increase in activation requirements. This method however gives the current view of the state
////	 * and takes into account decreases too
////	 * @return
////	 * @since 2.4.0.3
////	 */
////
////	public DownloadActivationEvent
////	getActivationState();
////
////	/**
////	 * Gives access to the download's statistics
////	 * @return
////   *
////   * @since 2.0.7.0
////	 */
////	public DownloadStats
////	getStats();
//
//	/** Downloads can be persistent (be remembered accross Azureus sessions), or
//	 * non-persistent.
//	 *
//	 * @return true - persistent<br>
//	 *         false - non-persistent
//     *
//     * @since 2.1.0.0
//	 */
//
//    public boolean
//    isPersistent();
//
//    /**
//     * Sets the maximum download speed in bytes per second. 0 -> unlimited
//     * @since 2.1.0.2
//     * @param kb
//     */
//
//  	public void
//	setMaximumDownloadKBPerSecond(
//		int		kb );
//
//  	public int
//	getMaximumDownloadKBPerSecond();
//
//
//	    /**
//	     * Get the max upload rate allowed for this download.
//	     * @return upload rate in bytes per second, 0 for unlimited, -1 for upload disabled
//	     */
//
//    public int getUploadRateLimitBytesPerSecond();
//
//	    /**
//	     * Set the max upload rate allowed for this download.
//	     * @param max_rate_bps limit in bytes per second, 0 for unlimited, -1 for upload disabled
//	     */
//
//    public void setUploadRateLimitBytesPerSecond( int max_rate_bps );
//
//	    /**
//	     * Get the max download rate allowed for this download.
//	     * @return upload rate in bytes per second, 0 for unlimited, -1 for download disabled
//	     * @since 3013
//	     */
//
//    public int getDownloadRateLimitBytesPerSecond();
//
//	    /**
//	     * Set the max download rate allowed for this download.
//	     * @param max_rate_bps limit in bytes per second, 0 for unlimited, -1 for dowmload disabled
//	     * @since 3013
//	     */
//
//    public void setDownloadRateLimitBytesPerSecond( int max_rate_bps );
//
//
//	/**
//	 * Indicates if the download has completed or not, exluding any files marked
//	 * as Do No Download
//	 *
//	 * @return Download Complete status
//	 * @since 2.1.0.4
//	 */
//	public boolean isComplete();
//
//	/**
//	 * Indicates if the download has completed or not
//	 *
//	 * @param bIncludeDND Whether to include DND files when determining
//	 *                     completion state
//	 * @return Download Complete status
//	 *
//	 * @since 2.4.0.3
//	 */
//	public boolean isComplete(boolean bIncludeDND);
//
//  		/**
//  		 * When a download is completed it is rechecked (if the option is enabled). This method
//  		 * returns true during this phase (at which time the status will be seeding)
//  		 * @return
//  		 * @since 2.3.0.6
//  		 */
//
//	public boolean
// 	isChecking();
//
//	/**
//	 * This returns the full save path for the download. If the download is a simple torrent,
//	 * this will be the full path of the file being downloaded. If the download is a multiple
//	 * file torrent, this will be the path to the directory containing all the files in the
//	 * torrent.
//	 *
//	 * @return Full save path for this download.
//	 */
//  	public String
//	getSavePath();
//
//  		/**
//  		 * Move a download's data files to a new location. Download must be stopped and persistent
//  		 *
//  		 * <p>
//  		 *
//  		 * If a download is running, it will be automatically paused and resumed afterwards - be
//  		 * aware that this behaviour may generate <tt>stateChanged</tt> events being fired.
//		 *
//		 * @since 2.3.0.5
//  		 * @param new_parent_dir
//  		 * @throws DownloadException
//  		 */
//
//  	public void
//  	moveDataFiles(
//  		File	new_parent_dir )
//
//  		throws DownloadException;
//
//  	/**
//  	 * Move a download's data files to a new location, and rename the download at the same time.
//  	 * Download must be stopped and persistent. This is equivalent to calling <tt>moveDataFiles[File]</tt>
//  	 * and then <tt>renameDownload[String]</tt>.
//  	 *
//  	 * For convenience, either argument can be <tt>null</tt>, but not both.
//  	 *
//  	 * <p>
//  	 *
//  	 * If a download is running, it will be automatically paused and resumed afterwards - be
//  	 * aware that this behaviour may generate <tt>stateChanged</tt> events being fired.
//  	 *
//  	 * @since 3.0.2
//  	 * @throws DownloadException
//  	 * @see {@link #moveDataFiles(File)}
//  	 * @see {@link #renameDownload(String)}
//  	 */
//  	public void moveDataFiles(File new_parent_dir, String new_name) throws DownloadException;
//
//
//  		/**
//		 * Move a download's torrent file to a new location. Download must be stopped and persistent
//		 * @since 2.3.0.5
//		 * @param new_parent_dir
//		 * @throws DownloadException
//		 */
//  	public void
//  	moveTorrentFile(
//  		File	new_parent_dir )
//
//  		throws DownloadException;
//
//  	/**
//  	 * Renames the file (for a single file torrent) or directory (for a multi file torrent) where the
//  	 * download is being saved to. The download must be in a state to move the data files to a new location
//  	 * (see {@link #moveDataFiles(File)}).
//  	 *
//  	 * <p>
//  	 *
//  	 * This will not rename the displayed name for the torrent - if you wish to do that, you must do it via
//  	 * the {@link org.gudy.azureus2.plugins.torrent.TorrentAttribute TorrentAttribute} class.
//  	 *
//  	 * <p>
//  	 *
//  	 * If a download is running, it will be automatically paused and resumed afterwards - be
//  	 * aware that this behaviour may generate <tt>stateChanged</tt> events being fired.
//  	 *
//  	 * @param name New name for the download.
//  	 * @see #moveDataFiles(File)
//  	 */
//  	public void renameDownload(String name) throws DownloadException;
//
  		/**
  		 * return the current peer manager for the download.
  		 * @return	null returned if torrent currently doesn't have one (e.g. it is stopped)
  		 */

  	public PeerManager
	getPeerManager();
////
////		/**
////		 * Return the disk manager, null if its not running
////		 * @return
////		 * @since 2.3.0.1
////		 */
////
////	public DiskManager
////	getDiskManager();
////
////		/**
////		 * Returns info about the torrent's files. Note that this will return "stub" values if the
////		 * download isn't running (not including info such as completion status)
////		 * @return
////		 * @since 2.3.0.1
////		 */
////
////	public DiskManagerFileInfo[]
////	getDiskManagerFileInfo();
//
//  		/**
//  		 * request a tracker announce
//  		 * @since 2.1.0.5
//  		 */
//
//  	public void
//	requestTrackerAnnounce();
//
//  		/**
//		 * request a tracker announce
//		 * @since 2.3.0.7
//		 */
//
// 	public void
//	requestTrackerAnnounce(
//		boolean		immediate );
//
//		/**
//		 * request a tracker announce
//		 * @since 2.3.0.7
//		 */
//
//	public void
//	requestTrackerScrape(
//		boolean		immediate );
//
//
//
//
//
//	/**
//	 * The torrents with the highest rankings will be seeded first.
//	 *
//	 * @return Seeding Rank
//	 */
//	public int getSeedingRank();
//
//	/**
//	 * The torrents with the highest rankings will be seeded first.
//	 *
//	 * @param rank New Ranking
//	 */
//	public void setSeedingRank(int rank);
//
  /**
   * Get the local peerID advertised to the download swarm.
   * @return self peer id
   *
   * @since 2.1.0.5
   */
  public byte[] getDownloadPeerId();

  /**
   * Is advanced AZ messaging enabled for this download.
   * @return true if enabled, false if disabled
   */
  public boolean isMessagingEnabled();

  /**
   * Enable or disable advanced AZ messaging for this download.
   * @param enabled true to enabled, false to disabled
   */
  public void setMessagingEnabled( boolean enabled );
//
//
//  /**
//   * Returns an array of size 2 indicating the appropriate locations for this
//   * download's data files and torrent file, based on Azureus's rules regarding
//   * default save paths, and move on completion rules.
//   *
//   * <p>
//   *
//   * This method takes one argument - <i>for_moving</i>. This essentially
//   * indicates whether you are getting this information for purposes of just
//   * finding where Azureus would store these files by default, or whether you
//   * are considering moving the files from its current location.
//   *
//   * <p>
//   *
//   * If <i>for_moving</i> is <tt>false</tt>, this method will determine locations
//   * for the download and the torrent file where Azureus would store them by
//   * default (it may return the current paths used by this download).
//   *
//   * <p>
//   *
//   * If <i>for_moving</i> is <tt>true</tt>, then this method will consider the
//   * download's current location, and whether it is allowed to move it - you
//   * may not be allowed to move this download (based on Azureus's current rules)
//   * if the download doesn't exist within a default save directory already. If
//   * a download is complete, we consider whether we are allowed to move downloads
//   * on completion, and whether that includes downloads outside the default save
//   * directory.
//   *
//   * <p>
//   *
//   * In this case, the array may contain <tt>null</tt> indicating that the Azureus
//   * doesn't believe that the download should be moved (based on the current rules
//   * the user has set out). However, you are not prevented from changing the
//   * location of the torrent file or download.
//   *
//   * @since 2.5.0.2
//   * @param for_moving Indicates whether you want this information for the purposes
//   *     of moving the download or not.
//   * @author amc1
//   * @deprecated Use {@link #calculateDefaultDownloadLocation()} instead.
//   * @return An array of type <tt>File</tt> of size 2, first element containing the
//   *     calculated location for the download's data files, and the second element
//   *     containing the location for the download's torrent file.
//   */
//  public File[] calculateDefaultPaths(boolean for_moving);
//
//  /**
//   * Returns <tt>true</tt> if the download is being saved to one of the default
//   * save directories.
//   *
//   * @since 2.5.0.2
//   * @deprecated Use {@link DefaultSaveLocationManager#isInDefaultSaveDir(Download)} instead.
//   * @author amc1
//   */
//  public boolean isInDefaultSaveDir();
//
//  /**
//   * @since 3.0.4.3
//   * @return
//   */
//
//  public boolean isRemoved();
//
//  /**
//   * Returns <tt>true</tt> if Azureus will allow the data files for the torrent
//   * to be moved.
//   *
//   * @since 3.0.5.1
//   */
//  public boolean canMoveDataFiles();
//
//  /**
//   * Returns a {@link SaveLocationChange} object describing the appropriate location
//   * for the download (and torrent file) to exist in, based on the download's completion
//   * state, the <tt>for-completion</tt> rules in place, and the {@link SaveLocationManager}
//   * object in use.
//   *
//   * @since 3.0.5.3
//   */
//  public SaveLocationChange calculateDefaultDownloadLocation();
//
//  /**
//   * Apply the changes in the given {@link SaveLocationChange} object - this includes
//   * moving torrent and data file data.
//   *
//   * @param slc The change to apply.
//   * @since 3.1.0.1
//   * @throws DownloadException If there is a problem moving the data.
//   */
//  public void changeLocation(SaveLocationChange slc) throws DownloadException;
//
//  	/**
//  	 * get user-defined key/value
//  	 * @param key
//  	 * @return
//  	 * @since 3.0.5.3
//  	 */
//
//  public Object getUserData( Object key );
//
//  	/**
//  	 * set user defined value. this is TRANSIENT and not persisted over Azureus stop/start
//  	 * @param key
//  	 * @param data
//  	 */
//  public void setUserData( Object key, Object data );
//
//  /**
//   * Simple method to start the download. Will not raise an error if it
//   * didn't work, or if the download is already running.
//   *
//   * @since 3.0.5.3
//   * @param force <tt>true</tt> to force the download to be started.
//   */
//  public void startDownload(boolean force);
//
//  /**
//   * Simple method to stop the download. Will not raise an error if it
//   * didn't work, or if the download is already stopped.
//   *
//   * @since 3.0.5.3
//   */
//  public void stopDownload();

  
}
